             / __    %%     2                |666|         99%   `  \ 
            /         %&    %       | :~"       ~~~         &' '##       \                 
           /      ^y        /-\        .   `        aAAa                 \
           :__~ ~    ..::.    ;. - \        .::.            
               ~  ..::::::.       \             
          ~~   ..::ĲĲ:::..      >      
              ֲ                䲳 
           +                 -->  :.      \\    
                                    ~\_
            .                `    `           \      :.
                    ~  $$%%       ?\        --    ! "
           & :.               `   ߴ   _  
                ....               \        \\   999    999 
          "~                     @@  ~  99  99  99  99 
             |my|   ~                   ~\       99999   99999
                              @       ֵֵ            99      99                         
           ~-_        ~  ~      @@                    99      99
                    -^y    ~~~ ~~                     999     999
              .:         ::..%..::                
          -version 1.0                                     [ cI[ERo ]

                                   --> fRACTUs`99 <--
                                        pRESENTs
                                      
   
             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
             | Keygen ( )   RegKey ( )   Regfile ( )   Crack (*)   Appz  ( )|                                                              
             |                                                              | 
             | Tutor  (*)   Progz  ( )   Message ( )   Filez ( )   Other ( )|                                                              
             |                                                              | 
             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~    
                       ( You should view this Tutor on Fullscreen! )

                              Tutor 1 by cI[ERo fRACTUs`99
                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Vorworte:
~~~~~~~~~

Dieser Tutor ist fr Anfnger gedacht und bezieht sich auf das cRACKEn (pATCHEn). Und erfordert nur wenige Kenntnisse.
Ich hoffe das ich den Tutor so schreiben kann, dass ihr ihn kapiert. Ich habe selber lange gesucht bis ich einen guten
deutschen Tutor bekam (An dieser Stelle mchte ich DANKE sagen an: `yOOZEr , Laxity , PC ). 
Als erstes solltet ihr wissen das es verschiedene Arten des cRACKENs gibt: Regkey-Hacken, cRACKEn (pATCHEn).
Dieser Tutor handelt ausschliesslich vom cRACKEn.
cRACKEN heisst das Programm so zu "manipulieren" das es wie eine Vollversion funktioniert.Dazu benutzt man einen Dissambler 
(ich empfehle den W32dasm Dissambler\Debugger), um den Ablauf einer Datei anzuzeigen.
Regkey-Hacken heisst den Registration-Key fr einen bestimmten Namen, der das Programm zur Vollversion macht, heraus zu finden.
Dazu wird im allgemeinen Softice Debugger verwendet. Das Regkey-Hacken ist in der Regel schwerer da die Programme oft fr jeden
Namen einen neuen Code berechnet. Das heisst ihr msst herausfinden WO, und WIE der Code kalkuliert wird...


Was ihr braucht:
~~~~~~~~~~~~~~~~
- W32dasm Dissambler\Debugger gibts auf unserer Homepage http:\\
- Einen Hexeditor ( Ich verwende Hexworkshop32 ; Version 2.10  Username cI[ERo  Serialnumber: jn11marq ) auch auf unserer
  Homepage!
- ca. 10 Minuten Zeit [Am lngsten wird das Lesen des Tutors dauern :-)]

Was wir tun werden:
~~~~~~~~~~~~~~~~~~~
Wir werden Techfacts95 von DeanSoftware cRACKEn.

Die Nags:
~~~~~~~~~
Nags sind die Stellen im Programm die uns immer wieder zeigen das unser Programm Shareware ist. Wie zum Beispiel "unregistered
Version" in der About Box u.. 
1) "About" Box, UNREGISTERED VERSION. Dort knnt ihr einen Regkey angeben, das freut uns sehr. ;-)
2) In der oberen Leiste des Programms steht "Techfacts95 <unregistered>" 
3) Bei Techfacts erscheint bei Jedem Start Eine Box Unregistered Version, und verschwindet nachein paar Sekunden wieder !   

Was zu tun ist:
~~~~~~~~~~~~~~~
<NAG1:>
Jetzt gehts los!!!
Als erstes kopieren wir die Datei Techfacts.exe und nennen die Kopie Techfacts95.dasm oder so hnlich.Dann laden wir diese Techfacts95.dasm in den W32dasm. Und die original Techfacts95.exe laden wir in den Hexworkshop.
Jetzt startet ihr das Programm, es erscheint diese hssliche gelbe Box.
 --> About --> Use Regkey --> (Irgendetwas eingeben). Es erscheint: "Registration Key failed". Das ist unser erster Ansatzpunkt.

!Wichtig! -- Wenn ihr im W32dasm nur seltsame Schriftzeichen siehst liegt das daran das ihr keine geeignete Schriftart gewhlt habt.
 Dissambler --> Font --> Select Font. Jetzt z.B. Times New Roman whlen. Dissambler --> Font --> Save Default Font.  

Ihr geht in den W32dasm und whlt in der oberen Leiste "StringDataReferences" und sucht den Eintrag "Registration Key failed".
Ein Doppelklick auf den Eintrag bringt euch zu dem Eintrag im Programm (Versucht mehrmals auf den Eintrag zu klicken, denn bei
manchen Programmen gibt es fr einen Eintrag mehrere Stellen im Programm.In diesem Fall jedoch nicht), ihr solltet jetzt folgendes
sehen:

* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:0047D394(C)                                                    <-- Von dieser Addresse im Programm kommt der Jump zu                                           dieser Stelle.(C) heisst Conditional,
                                                                     Jump mit Bedingung (siehe Assemblercode Liste!)
:0047D4C1 6A30                    push 00000030                  <-- Hier wird etwas in den Speicher geschrieben

* Reference To: user32.MessageBeep, Ord:0000h

:0047D4C3 E8688EF8FF              Call 00406330                  <-- Eine Callfunktion, hier unwichtig!

* Possible StringData Ref from Code Obj ->"Registration Key Failed!" <-- Der gesuchte Eintrag

Ihr msst den W32dasm von dem Eintrag an nach oben lesen!!!
                                              ~~~~
Jetzt mssen wir zurckverfolgen wo der Jump herkommt um ihn aufzuheben, denn wir wollen diese Meldung ja nicht mehr sehen!
Obere Leiste --> Goto Code Location --> 0047d394

:0047D394 0F8527010000            jne 0047D4C1  <-- Es handelt sich um einen "Jump if not equal"

Dieser Jump ist es also der, wenn wir einen Code eingeben, "Registration Key failed anzeigt! Wir mssen ihn also killen...
Ihr msst auf den Jump klicken, er wird grn hinterlegt.In der untersten Leiste des W32dasm erscheint:

"Line:<blablabla> @Offset0007C794h  <-- DAS ist wichtig: Das ist der Offset den dieser Sprung in Hex hat!!!
                                        Der Hexcode lautet nur 0007C794 , das h steht fr Hex und gehrt nicht zur Addresse.

Wir wechseln jetzt in den Hexworkshop --> Edit --> Goto --> <Offset eingeben> --> Go
Jetzt steht der Cursor auf E8688EF8FF <-- Das ist der Jump in Hex ausgedrckt.

Wir wollen das der Jump nicht mehr erfolgt, also bergangen wird.

-----------------------------------------------------------------------------------------------------------------------------
Ein wenig Assembling language:
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- Wir werden einen NOP verwenden. NOP steht fr "No Operation Point", und ist mit einem Loch in der Anwendung zu vergleichen.
  Der NOP bewirkt das der Jump ignoriert wird...genau das was wir wollen.
- Ein NOP hat den Hexwert 90.
-----------------------------------------------------------------------------------------------------------------------------

Wir mssen den gesamten Jump noppen, also heisst es spter nichtmehr E8688EF8FF sondern 9090909090 !!!
--> Speichern --> Techfacts aufrufen --> About --> Use Reg Key --> <Irgendwas eingeben> --> "Reg Key accepted!"
--> Licensed Version do not copy"
Das war Teil eins unseres cRACKs --> Problem: Bei jedem Start ist das Programm wieder unregistered.
WAS JETZT???

Keine Angst es geht gleich weiter:
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Wir wollen das in der About Box immer das "Licensed Version Do not copy" erscheint. Wir suchen wieder im W32dasm --> String
Data References ; diesemal aber nach "Licensed Version Do not copy". Wir kommen an diese Stelle im Programm:

* Referenced by a (U)nconditional or (C)onditional Jump at Addresses:
|:0048C582(C), :0048C5CD(C)              <-- Diesmal zwei Jumps die diesen Eintrag hervorrufen.Nennen wir sie Jump1 und Jump2
  Jump1         Jump2 
:0048C5F1 33D2                    xor edx, edx                             <-- Test des Speichers
:0048C5F3 8B83C4010000            mov eax, dword ptr [ebx+000001C4]        <-- Schreiben in den Speicher
:0048C5F9 E8F6A8F8FF              call 00416EF4                            <-- Aufruf einer anderen Prozedur 

* Possible StringData Ref from Code Obj ->"Licensed Version. Do Not Copy!"      <-- Der gesuchte Eintrag 

Es ist eigentlich wieder das gleiche wie vorhin.Wir mssen unterbinden das dieser Eintrag aufgerufen wird.
Jump1 zurckverfolgen: GotoCodeLocation --> 0048C582 

--> :0048C582 726D                    jb 0048C5F1

Wir kommen an einen jb - Jump if below. Dieser Jump ist fr uns unwichtig, das msst ihr mir jetzt halt mal glauben.:-)
Ihr knnt ihn natrlich noppen, aber das sollte nicht allzuviel bewirken.

Jump2 zurckverfolgen: GotoCodeLocation" --> 0048C5CD

--> :0048C5CD 7522                    jne 0048C5F1    <-- Jump if not equal 
    :0048C5CF B201                    mov dl, 01                              dieser Jump geht direkt zum Eintrag "Licensed 
    :0048C5D1 8B83C4010000            mov eax, dword ptr [ebx+000001C4]       Version Do not copy" 
    :0048C5D7 E818A9F8FF              call 00416EF4                           Allerding ist es ein Jump mit Bedingung 
                                                                              " if not equal"
    * Possible StringData Ref from Code Obj ->"<Unregistered Version>"      --> Jetzt mssen wir also diesen Jump Bedingungslos
                                                                                machen!!! Damit er immer zu diesen Eintrag 
    ----                                                                        springt            ~~~~~
    ----                                                                     Wie ihr seht wird durch diesen Jump der Eintrag
    ----                                                                     <Unregistered Version> bersprungen !!
                                                                           
   * Referenced by a (U)nconditional or (C)onditional Jump at Addresses:   
   |:0048C582(C), :0048C5CD(C)                                             
                                                                           
   :0048C5F1 33D2                    xor edx, edx                        
   :0048C5F3 8B83C4010000            mov eax, dword ptr [ebx+000001C4]
   :0048C5F9 E8F6A8F8FF              call 00416EF4   

   * Possible StringData Ref from Code Obj ->"Licensed Version. Do Not Copy!"  

-----------------------------------------------------------------------------------------------------------------------------
Assemblinglanguage:
~~~~~~~~~~~~~~~~~~~
Jump:         Hex:      Bedeutung:
~~~~~         ~~~~      ~~~~~~~~~~
jne           7522      Jump if not equal
        !kann variieren!
Wir wollen:
~~~~~~~~~~~
jmp            EB22      Jump ohne Bedingung

Ein Jump ohne Bedingung ist also EB. Wobei die letzten beiden Zahlen (Bei uns 22) unverndert bleiben!
----------------------------------------------------------------------------------------------------------------------------- 

Jetzt msst ihr wieder zum Hexworkshop wechseln um den Hexwert zu verndern. Der Offset dieses Jumps heisst: 0008B9CDh.
Das h wieder weglassen. Edit --> GOTO --> 0008B9CD --> Wir kommen an diese Stelle: 7522
--> ndern in EB22 --> Techfacts starten --> About --> Licensed Version Do not copy !!! ;-)

Das mit der About-Box ist also gegessen. Aber ich hoffe ihr habt die beiden anderen Nags nicht vergessen. Und die sind schwerer
zu finden. No Panic it`s not too hard! 

<NAG2> + <NAG3>
~~~~~~~~~~~~~~~
Wir erinnern uns das in der oberen Leiste von Techfacts95 immernoch Techfacts95<unregistered> steht.NEIN, das wollen wir nicht.
Wir knnten jetzt hingehen und diesen Eintrag im Hexworkshop suchen und aus <unregistered> -->  < registered >  machen.
WIE LANGWEILIG -- Klar es geht auch, aber das ist nicht cRACKEn sondern BULLSHIT! Alles klar?!?

W32dasm:
~~~~~~~~
Wir suchen also den Eintrag Techfacts95<unregistered> oder so hnlich. W32dasm --> StringDataReferences --> ?HH?
Bevor ihr zu fluchen anfangt: Ihr werdet diesen Eintrag nicht finden, aber jetzt nur nicht aufgeben.Sucht mal nach <unregistered>
--> TATA! Zwei Stellen im Programm tragen diesen Eintrag und sie liegen direkt untereinander. WAS FR EIN GLCK!

* Possible StringData Ref from Code Obj ->"Config"

:004C80D6 BA6C844C00              mov edx, 004C846C
:004C80DB 8B45FC                  mov eax, dword ptr [ebp-04]
:004C80DE E8F98FF8FF              call 004510DC
:004C80E3 8B45F8                  mov eax, dword ptr [ebp-08]
:004C80E6 50                      push eax
:004C80E7 8D45F4                  lea eax, dword ptr [ebp-0C]
:004C80EA BA8C694E00              mov edx, 004E698C
:004C80EF E85CB9F3FF              call 00403A50
:004C80F4 8B55F4                  mov edx, dword ptr [ebp-0C]
:004C80F7 58                      pop eax
:004C80F8 E8B7BAF3FF              call 00403BB4
:004C80FD 7441                    je 004C8140      <-- Conditional Jump     
:004C80FF C60517664E0000          mov byte ptr [004E6617], 00                
:004C8106 B201                    mov dl, 01                                 
:004C8108 8B8358020000            mov eax, dword ptr [ebx+00000258]          
:004C810E E869BAF6FF              call 00433B7C                              
:004C8113 66833D78664E0000        cmp word ptr [004E6678], 0000              
:004C811B 7562                    jne 004C817F                               
:004C811D 8D55F0                  lea edx, dword ptr [ebp-10]                 
:004C8120 8BC3                    mov eax, ebx                               
:004C8122 E871EEF4FF              call 00416F98                              
:004C8127 8D45F0                  lea eax, dword ptr [ebp-10]                
                                                                             
* Possible StringData Ref from Code Obj ->" <unregistered>" <--Eintrag        Da geht er hin unser Jump.Und wie ihr seht wird
                                                                              durch diesen Sprung der Eintrag <unregistered>
:004C812A BA7C844C00              mov edx, 004C847C                           bergangen.
:004C812F E878B9F3FF              call 00403AAC                              
:004C8134 8B55F0                  mov edx, dword ptr [ebp-10]                
:004C8137 8BC3                    mov eax, ebx                               
:004C8139 E88AEEF4FF              call 00416FC8                              
:004C813E EB3F                    jmp 004C817F                               
                                                                             
* Referenced by a (U)nconditional or (C)onditional Jump at Address:          
|:004C80FD(C)                                                                
                                                                             
:004C8140 66833D78664E0000        cmp word ptr [004E6678], 0000  <--- Jetzt sind wir also hier. Und jetzt...
:004C8148 7535                    jne 004C817F    <-- Der nchste Conditional Jump          
:004C814A C60517664E0001          mov byte ptr [004E6617], 01                       
:004C8151 B201                    mov dl, 01                                        
:004C8153 8B8358020000            mov eax, dword ptr [ebx+00000258]                 
:004C8159 E81EBAF6FF              call 00433B7C                                     
:004C815E 8D55F0                  lea edx, dword ptr [ebp-10]                       
:004C8161 8BC3                    mov eax, ebx                                       Und hier geht unser zweiter Jump hin,
:004C8163 E830EEF4FF              call 00416F98                                      diesmal wird dabei der zweite <unregistered>
:004C8168 8D45F0                  lea eax, dword ptr [ebp-10]                        Eintrag bergangen.
                                                                                    
* Possible StringData Ref from Code Obj ->" <unregistered>"  <-- Der zweite Eintrag 
                                                                                    
:004C816B BA7C844C00              mov edx, 004C847C                                 
:004C8170 E837B9F3FF              call 00403AAC                                      
:004C8175 8B55F0                  mov edx, dword ptr [ebp-10]                       
:004C8178 8BC3                    mov eax, ebx                                      
:004C817A E849EEF4FF              call 00416FC8                                      
                                                                                    
* Referenced by a (U)nconditional or (C)onditional Jump at Addresses:               
|:004C811B(C), :004C813E(U), :004C8148(C)                                            
                                                                                    
:004C817F 6A00                    push 00000000       <-- Jetzt stehen wir hier !!! GESCHAFFT !!!

In Worten:
~~~~~~~~~~
Falls ihr es aus meiner supertollen Skizze noch nicht habt entnehmen knnen hier der Rest des cRACKs in Worten.
Wenn ihr im "StringDataReferences" auf <unregistered> klickt steht ihr beim ersten oder zweiten Eintrag.Ihr msst wie beim
ersten Teil den Programmcode von unten nach oben lesen.Also scrollt ihr mal ein bichen nach oben, bis ihr eben zu diesem
Jump kommt.Jetzt schaut ihr wohin dieser Jump fhrt --> ihr werdet entdecken das er den Eintrag berspringt, und das wollen
wir ja. Problem: Der Sprung hat eine Bedingung, welche lautet Jump if equal  -->Das bedeutet: Spring nur wenn es Vollversion
ist --> Also bezahlen und registrieren  --> oder cRACKEn
Ich schlage cRACKEn vor, ist billiger und macht mehr Spa.
Der Sprung soll also immer erfolgen, ob Voll- oder Sharewareversion.Wir erinnern uns an den Assemblinglanguage-Teil weiter
oben EB = Unconditional (Bedingungslos)
Also Offset das jne gemerkt 000C74FD --> Ab in den Hexworks --> Edit --> Goto --> <Offset eingeben>
--> Wir stehen an der Stelle: 7441 
--> EB                      : EB41  !die letzten beiden Zahlen bleiben immer stehen!
                                                                       ~~~~~
Soweit so gut, aber was ist mit dem zweiten Eintrag???
Im W32dasm stehen wir nach diesem Sprung hinter dem ersten Eintrag bei 004C8140 ..blablabla.. cmp word ptr ...blabla...
Jetzt gehen wir weiter nach unten, in der nchsten Zeile steht  :004C8148   7535    jne  004C817F 
Wieder ein Jump mit Bedingung.Und dieser berspringt den zweiten <unregistered> Eintrag! Same procedure as every Jump!
Wieder Offset merken (000C7548h - "h" weglassen!) --> Hexworks --> Edit --> Goto --> Offset angeben -->7535 --> EB35 -->Save
Jetzt seid ihr sowohl lizensierter User von Techfacts95 und auch die Nags (incl. Gelber Box!) sind verschwunden. 
Der Witz mit der doppelten "Sicherung"...HAHAHA ICH LACH MICH TOT  
--> Fr mich sind Dean Software alles LOOSER!

-----------------------------------------------------------------------------------------------------------------------------
Assemblinglanguage:
~~~~~~~~~~~~~~~~~~~                             
Hexwert:   Assembler:   bersetzung:
~~~~~~~~   ~~~~~~~~~    ~~~~~~~~~~~~
75 or 0F85    jne       jump if not equal
74 or 0F84    je        jump if equal
EB            jmp       jump directly to   [Unconditional]
90            nop       No Operation Point

----  Die jetzt folgenden Jumps sind ziemlich selten und doch sollte man sie kennen um ein Programm richtig zu lesen!
 
77 or 0F87    ja        jump if above
0F86          jna       jump if not above
0F83          jae       jump if above or equal
0F82          jnae      jump if not above or equal
0F82          jb        jump if below
0F83          jnb       jump if not below
0F86          jbe       jump if below or equal
0F87          jnbe      jump if not below or equal
0F8F          jg        jump if greater
0F8E          jng       jump if not greater
0F8D          jge       jump if greater or equal
0F8C          jnge      jump if not greater or equal
0F8C          jl        jump if less
0F8D          jnl       jump if not less
0F8E          jle       jump if less or equal
0F8F          jnle      jump if not less or equal
-----------------------------------------------------------------------------------------------------------------------------





                                              --> fRACTUs`99 is <--
                                                

 [ `yOOZEr ........... fOUNDEr/cRACKEr............................... yOOZEr@gmx.net    ]
 [  cI[ERo  ........... cRACKEr/nFo/wWw .............................. fRACTUs99@gmx.net ]

    
  Wenn euch dieser Tutor wirklich geholfen hat das cRACKEn zu erlernen knnt ihr mir eine E-MAil schicken, aber auch 
  wenn etwas unklar, oder schlecht erklrt war solltet ihr mir das mitteilen es kann nur besser werden.              
                                                                                                                     
  If you`re a cRACKEr and want to join, connect us at: http://                                                       
                                                                                                                      
                         fRACTUs`99  cRACKs of your choice!                                                          

  
pERSONAl gREETz
                                  ~~~~~~~~~~~~~~~                                                                    
          cI[ERo says tHANx to the following gUYs and oRGANISATIONs:                                                 
                                                                                                                     
 --  Laxity ......xCrk...Animalo...VTeC                                                                              
                                                                                                                     
 --  PC     ......tHAtdUDe...tkc                                                                                     
                                                                                                                     


tHAt`s iT!!! 
                                         